<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE BangPatterns, CPP, MagicHash, RankNTypes, ScopedTypeVariables,
    UnboxedTuples #-}</span><span>
</span><span id="line-3"></span><span class="hs-pragma">{-# LANGUAGE Trustworthy #-}</span><span>
</span><span id="line-4"></span><span>
</span><span id="line-5"></span><span class="hs-comment">-- Module:      Data.Text.Lazy.Builder.Int</span><span>
</span><span id="line-6"></span><span class="hs-comment">-- Copyright:   (c) 2013 Bryan O'Sullivan</span><span>
</span><span id="line-7"></span><span class="hs-comment">--              (c) 2011 MailRank, Inc.</span><span>
</span><span id="line-8"></span><span class="hs-comment">-- License:     BSD-style</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- Maintainer:  Bryan O'Sullivan &lt;bos@serpentine.com&gt;</span><span>
</span><span id="line-10"></span><span class="hs-comment">-- Portability: portable</span><span>
</span><span id="line-11"></span><span class="hs-comment">--</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- Efficiently write an integral value to a 'Builder'.</span><span>
</span><span id="line-13"></span><span>
</span><span id="line-14"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Data.Text.Lazy.Builder.Int</span><span>
</span><span id="line-15"></span><span>    </span><span class="hs-special">(</span><span>
</span><span id="line-16"></span><span>      </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-identifier">decimal</span></a></span><span>
</span><span id="line-17"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-identifier">hexadecimal</span></a></span><span>
</span><span id="line-18"></span><span>    </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-19"></span><span>
</span><span id="line-20"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Int.html#"><span class="hs-identifier">Data.Int</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Int.html#Int8"><span class="hs-identifier">Int8</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-identifier">Int16</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-identifier">Int32</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier">Int64</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-21"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Monoid.html#"><span class="hs-identifier">Data.Monoid</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier">mempty</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-22"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Unsafe.html#"><span class="hs-identifier">Data.ByteString.Unsafe</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">B</span></span><span>
</span><span id="line-23"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.Functions.html"><span class="hs-identifier">Data.Text.Internal.Builder.Functions</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Text.Internal.Builder.Functions.html#%3C%3E"><span class="hs-operator">(&lt;&gt;)</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.Functions.html#i2d"><span class="hs-identifier">i2d</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-24"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html"><span class="hs-identifier">Data.Text.Internal.Builder</span></a></span><span>
</span><span id="line-25"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.Int.Digits.html"><span class="hs-identifier">Data.Text.Internal.Builder.Int.Digits</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Text.Internal.Builder.Int.Digits.html#digits"><span class="hs-identifier">digits</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-26"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Text.Array.html"><span class="hs-identifier">Data.Text.Array</span></a></span><span>
</span><span id="line-27"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Word.html#"><span class="hs-identifier">Data.Word</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Word"><span class="hs-identifier">Word</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier">Word8</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier">Word16</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier">Word32</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier">Word64</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-28"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#"><span class="hs-identifier">GHC.Base</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#quotInt"><span class="hs-identifier">quotInt</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#remInt"><span class="hs-identifier">remInt</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-29"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.ST.html#"><span class="hs-identifier">Control.Monad.ST</span></a></span><span class="hs-cpp">
#if MIN_VERSION_base(4,11,0)
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Prelude.html#"><span class="hs-identifier">Prelude</span></a></span><span> </span><span class="hs-keyword">hiding</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator">(&lt;&gt;)</span></a></span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-34"></span><span id="local-6989586621679115129"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-identifier hs-type">decimal</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679115129"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679115129"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-identifier hs-type">Builder</span></a></span></span><span>
</span><span id="line-35"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Int8&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-pragma hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int8"><span class="hs-pragma hs-type">Int8</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-36"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Int&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-pragma hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-pragma hs-type">Int</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-37"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Int16&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-pragma hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-pragma hs-type">Int16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-38"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Int32&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-pragma hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-pragma hs-type">Int32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-39"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Int64&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-pragma hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-pragma hs-type">Int64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-40"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Word&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Word"><span class="hs-pragma hs-type">Data.Word.Word</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-41"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Word8&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-pragma hs-type">Word8</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-42"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Word16&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-pragma hs-type">Word16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-43"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Word32&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-pragma hs-type">Word32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-44"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Word64&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-pragma hs-type">Word64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-45"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;decimal/Integer&quot;</span></span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#integer"><span class="hs-pragma hs-type">integer</span></a></span><span> </span><span class="annot"><span class="hs-pragma">10</span></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><span class="hs-pragma hs-type">Integer</span></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-46"></span><span id="decimal"><span class="annot"><span class="annottext">decimal :: forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-identifier hs-var hs-var">decimal</span></a></span></span><span> </span><span id="local-6989586621679114967"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114967"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Bool) -&gt; a -&gt; Builder
forall a. Integral a =&gt; (a -&gt; Bool) -&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#decimal%27"><span class="hs-identifier hs-var">decimal'</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C%3D"><span class="hs-operator hs-var">&lt;=</span></a></span><span> </span><span class="hs-glyph">-</span><span class="annot"><span class="annottext">a
</span><span class="hs-number">128</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114967"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-47"></span><span class="hs-pragma">{-# NOINLINE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-pragma hs-type">decimal</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-48"></span><span>
</span><span id="line-49"></span><span id="local-6989586621679115122"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-identifier hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679115122"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Enum.html#Bounded"><span class="hs-identifier hs-type">Bounded</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679115122"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679115122"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-identifier hs-type">Builder</span></a></span></span><span>
</span><span id="line-50"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-pragma hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-pragma hs-type">Int</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-51"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-pragma hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int8"><span class="hs-pragma hs-type">Int8</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-52"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-pragma hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-pragma hs-type">Int16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-53"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-pragma hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-pragma hs-type">Int32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-54"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-pragma hs-type">boundedDecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-pragma hs-type">Int64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-55"></span><span id="boundedDecimal"><span class="annot"><span class="annottext">boundedDecimal :: forall a. (Integral a, Bounded a) =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#boundedDecimal"><span class="hs-identifier hs-var hs-var">boundedDecimal</span></a></span></span><span> </span><span id="local-6989586621679114955"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114955"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Bool) -&gt; a -&gt; Builder
forall a. Integral a =&gt; (a -&gt; Bool) -&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#decimal%27"><span class="hs-identifier hs-var">decimal'</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">a
forall a. Bounded a =&gt; a
</span><a href="../../base/src/GHC.Enum.html#minBound"><span class="hs-identifier hs-var">minBound</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114955"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-56"></span><span>
</span><span id="line-57"></span><span id="local-6989586621679115124"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal%27"><span class="hs-identifier hs-type">decimal'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679115124"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679115124"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679115124"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-identifier hs-type">Builder</span></a></span></span><span>
</span><span id="line-58"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#decimal%27"><span class="hs-pragma hs-type">decimal'</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-59"></span><span id="decimal%27"><span class="annot"><span class="annottext">decimal' :: forall a. Integral a =&gt; (a -&gt; Bool) -&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#decimal%27"><span class="hs-identifier hs-var hs-var">decimal'</span></a></span></span><span> </span><span id="local-6989586621679114942"><span class="annot"><span class="annottext">a -&gt; Bool
</span><a href="#local-6989586621679114942"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679114941"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114941"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-60"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114941"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">a -&gt; Bool
</span><a href="#local-6989586621679114942"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114941"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-61"></span><span>              </span><span class="hs-keyword">then</span><span> </span><span class="hs-keyword">let</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679114937"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114937"><span class="hs-identifier hs-var">q</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679114936"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114936"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114941"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; (a, a)
forall a. Integral a =&gt; a -&gt; a -&gt; (a, a)
</span><a href="../../base/src/GHC.Real.html#quotRem"><span class="hs-operator hs-var">`quotRem`</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">10</span></span><span>
</span><span id="line-62"></span><span>                       </span><span id="local-6989586621679114933"><span class="annot"><span class="annottext">qq :: a
</span><a href="#local-6989586621679114933"><span class="hs-identifier hs-var hs-var">qq</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">-</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114937"><span class="hs-identifier hs-var">q</span></a></span><span>
</span><span id="line-63"></span><span>                       </span><span class="hs-glyph">!</span><span id="local-6989586621679114931"><span class="annot"><span class="annottext">n :: Int
</span><a href="#local-6989586621679114931"><span class="hs-identifier hs-var hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Int
forall a. Integral a =&gt; a -&gt; Int
</span><a href="Data.Text.Lazy.Builder.Int.html#countDigits"><span class="hs-identifier hs-var">countDigits</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114933"><span class="hs-identifier hs-var">qq</span></a></span><span>
</span><span id="line-64"></span><span>                   </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder
</span><a href="Data.Text.Internal.Builder.html#writeN"><span class="hs-identifier hs-var">writeN</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114931"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">((forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder)
-&gt; (forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679114916"><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114916"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span id="local-6989586621679114915"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114915"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-65"></span><span>                       </span><span class="annot"><span class="annottext">MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
forall s. MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
</span><a href="Data.Text.Array.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114916"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114915"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#minus"><span class="hs-identifier hs-var">minus</span></a></span><span>
</span><span id="line-66"></span><span>                       </span><span class="annot"><span class="annottext">MArray s -&gt; Int -&gt; Int -&gt; a -&gt; ST s ()
forall a s. Integral a =&gt; MArray s -&gt; Int -&gt; Int -&gt; a -&gt; ST s ()
</span><a href="Data.Text.Lazy.Builder.Int.html#posDecimal"><span class="hs-identifier hs-var">posDecimal</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114916"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114915"><span class="hs-identifier hs-var">off</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114931"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114933"><span class="hs-identifier hs-var">qq</span></a></span><span>
</span><span id="line-67"></span><span>                       </span><span class="annot"><span class="annottext">MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
forall s. MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
</span><a href="Data.Text.Array.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114916"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114915"><span class="hs-identifier hs-var">off</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114931"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Word16
forall a. Integral a =&gt; a -&gt; Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#i2w"><span class="hs-identifier hs-var">i2w</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">-</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114936"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-68"></span><span>              </span><span class="hs-keyword">else</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679114909"><span class="annot"><span class="annottext">j :: a
</span><a href="#local-6989586621679114909"><span class="hs-identifier hs-var hs-var">j</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">-</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114941"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-69"></span><span>                       </span><span class="hs-glyph">!</span><span id="local-6989586621679114907"><span class="annot"><span class="annottext">n :: Int
</span><a href="#local-6989586621679114907"><span class="hs-identifier hs-var hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Int
forall a. Integral a =&gt; a -&gt; Int
</span><a href="Data.Text.Lazy.Builder.Int.html#countDigits"><span class="hs-identifier hs-var">countDigits</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114909"><span class="hs-identifier hs-var">j</span></a></span><span>
</span><span id="line-70"></span><span>                   </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder
</span><a href="Data.Text.Internal.Builder.html#writeN"><span class="hs-identifier hs-var">writeN</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114907"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">((forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder)
-&gt; (forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679114902"><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114902"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span id="local-6989586621679114901"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114901"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-71"></span><span>                       </span><span class="annot"><span class="annottext">MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
forall s. MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
</span><a href="Data.Text.Array.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114902"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114901"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#minus"><span class="hs-identifier hs-var">minus</span></a></span><span> </span><span class="annot"><span class="annottext">ST s () -&gt; ST s () -&gt; ST s ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s -&gt; Int -&gt; Int -&gt; a -&gt; ST s ()
forall a s. Integral a =&gt; MArray s -&gt; Int -&gt; Int -&gt; a -&gt; ST s ()
</span><a href="Data.Text.Lazy.Builder.Int.html#posDecimal"><span class="hs-identifier hs-var">posDecimal</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114902"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114901"><span class="hs-identifier hs-var">off</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114907"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114909"><span class="hs-identifier hs-var">j</span></a></span><span>
</span><span id="line-72"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Builder
forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-identifier hs-var">positive</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114941"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-73"></span><span>
</span><span id="line-74"></span><span id="local-6989586621679114900"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-identifier hs-type">positive</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679114900"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679114900"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-identifier hs-type">Builder</span></a></span></span><span>
</span><span id="line-75"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-pragma hs-type">Int</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-76"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int8"><span class="hs-pragma hs-type">Int8</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-77"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-pragma hs-type">Int16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-78"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-pragma hs-type">Int32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-79"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-pragma hs-type">Int64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-80"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Word"><span class="hs-pragma hs-type">Word</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-81"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-pragma hs-type">Word8</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-82"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-pragma hs-type">Word16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-83"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-pragma hs-type">Word32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-84"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-pragma hs-type">positive</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-pragma hs-type">Word64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-85"></span><span id="positive"><span class="annot"><span class="annottext">positive :: forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#positive"><span class="hs-identifier hs-var hs-var">positive</span></a></span></span><span> </span><span id="local-6989586621679114893"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114893"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-86"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114893"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">10</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder
</span><a href="Data.Text.Internal.Builder.html#writeN"><span class="hs-identifier hs-var">writeN</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">((forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder)
-&gt; (forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679114891"><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114891"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span id="local-6989586621679114890"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114890"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
forall s. MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
</span><a href="Data.Text.Array.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114891"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114890"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Word16
forall a. Integral a =&gt; a -&gt; Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#i2w"><span class="hs-identifier hs-var">i2w</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114893"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-87"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679114888"><span class="annot"><span class="annottext">n :: Int
</span><a href="#local-6989586621679114888"><span class="hs-identifier hs-var hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Int
forall a. Integral a =&gt; a -&gt; Int
</span><a href="Data.Text.Lazy.Builder.Int.html#countDigits"><span class="hs-identifier hs-var">countDigits</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114893"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-88"></span><span>                  </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder
</span><a href="Data.Text.Internal.Builder.html#writeN"><span class="hs-identifier hs-var">writeN</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114888"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">((forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder)
-&gt; (forall s. MArray s -&gt; Int -&gt; ST s ()) -&gt; Builder
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679114886"><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114886"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span id="local-6989586621679114885"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114885"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">MArray s -&gt; Int -&gt; Int -&gt; a -&gt; ST s ()
forall a s. Integral a =&gt; MArray s -&gt; Int -&gt; Int -&gt; a -&gt; ST s ()
</span><a href="Data.Text.Lazy.Builder.Int.html#posDecimal"><span class="hs-identifier hs-var">posDecimal</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114886"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114885"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114888"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114893"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-89"></span><span>
</span><span id="line-90"></span><span id="local-6989586621679115106"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#posDecimal"><span class="hs-identifier hs-type">posDecimal</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679115106"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span>
</span><span id="line-91"></span><span>              </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679115105"><span class="annot"><a href="#local-6989586621679115105"><span class="hs-identifier hs-type">s</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Data.Text.Array.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679115105"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679115106"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679115105"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-92"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#posDecimal"><span class="hs-pragma hs-type">posDecimal</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-93"></span><span id="posDecimal"><span class="annot"><span class="annottext">posDecimal :: forall a s. Integral a =&gt; MArray s -&gt; Int -&gt; Int -&gt; a -&gt; ST s ()
</span><a href="Data.Text.Lazy.Builder.Int.html#posDecimal"><span class="hs-identifier hs-var hs-var">posDecimal</span></a></span></span><span> </span><span id="local-6989586621679114879"><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114879"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span id="local-6989586621679114878"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114878"><span class="hs-identifier hs-var">off0</span></a></span></span><span> </span><span id="local-6989586621679114877"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114877"><span class="hs-identifier hs-var">ds</span></a></span></span><span> </span><span id="local-6989586621679114876"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114876"><span class="hs-identifier hs-var">v0</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ST s ()
forall {p}. Integral p =&gt; Int -&gt; p -&gt; ST s ()
</span><a href="#local-6989586621679114875"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114878"><span class="hs-identifier hs-var">off0</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114877"><span class="hs-identifier hs-var">ds</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114876"><span class="hs-identifier hs-var">v0</span></a></span><span>
</span><span id="line-94"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679114875"><span class="annot"><span class="annottext">go :: Int -&gt; p -&gt; ST s ()
</span><a href="#local-6989586621679114875"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621679114860"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114860"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span id="local-6989586621679114859"><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114859"><span class="hs-identifier hs-var">v</span></a></span></span><span>
</span><span id="line-95"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114859"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">p -&gt; p -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">100</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-96"></span><span>               </span><span class="hs-keyword">let</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679114856"><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114856"><span class="hs-identifier hs-var">q</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679114855"><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114855"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114859"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">p -&gt; p -&gt; (p, p)
forall a. Integral a =&gt; a -&gt; a -&gt; (a, a)
</span><a href="../../base/src/GHC.Real.html#quotRem"><span class="hs-operator hs-var">`quotRem`</span></a></span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">100</span></span><span>
</span><span id="line-97"></span><span>               </span><span class="annot"><span class="annottext">Int -&gt; p -&gt; ST s ()
forall {p}. Integral p =&gt; Int -&gt; p -&gt; ST s ()
</span><a href="#local-6989586621679114854"><span class="hs-identifier hs-var">write2</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114860"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114855"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-98"></span><span>               </span><span class="annot"><span class="annottext">Int -&gt; p -&gt; ST s ()
</span><a href="#local-6989586621679114875"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114860"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114856"><span class="hs-identifier hs-var">q</span></a></span><span>
</span><span id="line-99"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114859"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">p -&gt; p -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">10</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
forall s. MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
</span><a href="Data.Text.Array.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114879"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114860"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">p -&gt; Word16
forall a. Integral a =&gt; a -&gt; Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#i2w"><span class="hs-identifier hs-var">i2w</span></a></span><span> </span><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114859"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-100"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; p -&gt; ST s ()
forall {p}. Integral p =&gt; Int -&gt; p -&gt; ST s ()
</span><a href="#local-6989586621679114854"><span class="hs-identifier hs-var">write2</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114860"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114859"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-101"></span><span>        </span><span id="local-6989586621679114854"><span class="annot"><span class="annottext">write2 :: Int -&gt; p -&gt; ST s ()
</span><a href="#local-6989586621679114854"><span class="hs-identifier hs-var hs-var">write2</span></a></span></span><span> </span><span id="local-6989586621679114847"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114847"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span id="local-6989586621679114846"><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114846"><span class="hs-identifier hs-var">i0</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-102"></span><span>          </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679114843"><span class="annot"><span class="annottext">i :: Int
</span><a href="#local-6989586621679114843"><span class="hs-identifier hs-var hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">p -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679114846"><span class="hs-identifier hs-var">i0</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679114841"><span class="annot"><span class="annottext">j :: Int
</span><a href="#local-6989586621679114841"><span class="hs-identifier hs-var hs-var">j</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114843"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114843"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-103"></span><span>          </span><span class="annot"><span class="annottext">MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
forall s. MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
</span><a href="Data.Text.Array.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114879"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114847"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="annot"><span class="annottext">(Word16 -&gt; ST s ()) -&gt; Word16 -&gt; ST s ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Word16
</span><a href="#local-6989586621679114840"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114841"><span class="hs-identifier hs-var">j</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span>
</span><span id="line-104"></span><span>          </span><span class="annot"><span class="annottext">MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
forall s. MArray s -&gt; Int -&gt; Word16 -&gt; ST s ()
</span><a href="Data.Text.Array.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">MArray s
</span><a href="#local-6989586621679114879"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114847"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Word16 -&gt; ST s ()) -&gt; Word16 -&gt; ST s ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Word16
</span><a href="#local-6989586621679114840"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114841"><span class="hs-identifier hs-var">j</span></a></span><span>
</span><span id="line-105"></span><span>        </span><span id="local-6989586621679114840"><span class="annot"><span class="annottext">get :: Int -&gt; Word16
</span><a href="#local-6989586621679114840"><span class="hs-identifier hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#word8ToWord16"><span class="hs-identifier hs-var">word8ToWord16</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word16) -&gt; (Int -&gt; Word8) -&gt; Int -&gt; Word16
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-identifier hs-var">B.unsafeIndex</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="Data.Text.Internal.Builder.Int.Digits.html#digits"><span class="hs-identifier hs-var">digits</span></a></span><span>
</span><span id="line-106"></span><span>
</span><span id="line-107"></span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#minus"><span class="hs-identifier hs-type">minus</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#zero"><span class="hs-identifier hs-type">zero</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-108"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#minus"><span class="hs-pragma hs-type">minus</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-109"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#zero"><span class="hs-pragma hs-type">zero</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-110"></span><span id="minus"><span class="annot"><span class="annottext">minus :: Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#minus"><span class="hs-identifier hs-var hs-var">minus</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16
</span><span class="hs-number">45</span></span><span>
</span><span id="line-111"></span><span id="zero"><span class="annot"><span class="annottext">zero :: Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#zero"><span class="hs-identifier hs-var hs-var">zero</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16
</span><span class="hs-number">48</span></span><span>
</span><span id="line-112"></span><span>
</span><span id="line-113"></span><span id="local-6989586621679115104"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#i2w"><span class="hs-identifier hs-type">i2w</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679115104"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679115104"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span></span><span>
</span><span id="line-114"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#i2w"><span class="hs-pragma hs-type">i2w</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-115"></span><span id="i2w"><span class="annot"><span class="annottext">i2w :: forall a. Integral a =&gt; a -&gt; Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#i2w"><span class="hs-identifier hs-var hs-var">i2w</span></a></span></span><span> </span><span id="local-6989586621679114831"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114831"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#zero"><span class="hs-identifier hs-var">zero</span></a></span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Word16 -&gt; Word16
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114831"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-116"></span><span>
</span><span id="line-117"></span><span id="local-6989586621679115117"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#countDigits"><span class="hs-identifier hs-type">countDigits</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679115117"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679115117"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span></span><span>
</span><span id="line-118"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#countDigits"><span class="hs-pragma hs-type">countDigits</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-119"></span><span id="countDigits"><span class="annot"><span class="annottext">countDigits :: forall a. Integral a =&gt; a -&gt; Int
</span><a href="Data.Text.Lazy.Builder.Int.html#countDigits"><span class="hs-identifier hs-var hs-var">countDigits</span></a></span></span><span> </span><span id="local-6989586621679114817"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114817"><span class="hs-identifier hs-var">v0</span></a></span></span><span>
</span><span id="line-120"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; a
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114816"><span class="hs-identifier hs-var">v64</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114817"><span class="hs-identifier hs-var">v0</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Word64 -&gt; Int
forall {t}. Num t =&gt; t -&gt; Word64 -&gt; t
</span><a href="#local-6989586621679114815"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114816"><span class="hs-identifier hs-var">v64</span></a></span><span>
</span><span id="line-121"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>              </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Integer -&gt; Int
forall {t}. Num t =&gt; t -&gt; Integer -&gt; t
</span><a href="#local-6989586621679114814"><span class="hs-identifier hs-var">goBig</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Integer
forall a. Integral a =&gt; a -&gt; Integer
</span><a href="../../base/src/GHC.Real.html#toInteger"><span class="hs-identifier hs-var">toInteger</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114817"><span class="hs-identifier hs-var">v0</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-122"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679114816"><span class="annot"><span class="annottext">v64 :: Word64
</span><a href="#local-6989586621679114816"><span class="hs-identifier hs-var hs-var">v64</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114817"><span class="hs-identifier hs-var">v0</span></a></span><span>
</span><span id="line-123"></span><span>        </span><span id="local-6989586621679114814"><span class="annot"><span class="annottext">goBig :: t -&gt; Integer -&gt; t
</span><a href="#local-6989586621679114814"><span class="hs-identifier hs-var hs-var">goBig</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679114802"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114802"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679114801"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114801"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span class="hs-special">)</span><span>
</span><span id="line-124"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114801"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114799"><span class="hs-identifier hs-var">big</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">t -&gt; Integer -&gt; t
</span><a href="#local-6989586621679114814"><span class="hs-identifier hs-var">goBig</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114802"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">19</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114801"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#quot"><span class="hs-operator hs-var">`quot`</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114799"><span class="hs-identifier hs-var">big</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-125"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">t -&gt; Word64 -&gt; t
forall {t}. Num t =&gt; t -&gt; Word64 -&gt; t
</span><a href="#local-6989586621679114815"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114802"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Word64
forall a. Num a =&gt; Integer -&gt; a
</span><a href="../../base/src/GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114801"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-126"></span><span>        </span><span id="local-6989586621679114799"><span class="annot"><span class="annottext">big :: Integer
</span><a href="#local-6989586621679114799"><span class="hs-identifier hs-var hs-var">big</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">10000000000000000000</span></span><span>
</span><span id="line-127"></span><span>        </span><span id="local-6989586621679114815"><span class="annot"><span class="annottext">go :: t -&gt; Word64 -&gt; t
</span><a href="#local-6989586621679114815"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679114748"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114748"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679114747"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-128"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">10</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114748"><span class="hs-identifier hs-var">k</span></a></span><span>
</span><span id="line-129"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">100</span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114748"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">1</span></span><span>
</span><span id="line-130"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">1000</span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114748"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">2</span></span><span>
</span><span id="line-131"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">1000000000000</span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-132"></span><span>               </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114748"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">100000000</span></span><span>
</span><span id="line-133"></span><span>                   </span><span class="hs-keyword">then</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">1000000</span></span><span>
</span><span id="line-134"></span><span>                        </span><span class="hs-keyword">then</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">10000</span></span><span>
</span><span id="line-135"></span><span>                             </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">3</span></span><span>
</span><span id="line-136"></span><span>                             </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">4</span></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; t
forall {a} {p}. (Ord a, Num p) =&gt; a -&gt; a -&gt; p
</span><a href="#local-6989586621679114746"><span class="hs-identifier hs-var">fin</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">100000</span></span><span>
</span><span id="line-137"></span><span>                        </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">6</span></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; t
forall {a} {p}. (Ord a, Num p) =&gt; a -&gt; a -&gt; p
</span><a href="#local-6989586621679114746"><span class="hs-identifier hs-var">fin</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">10000000</span></span><span>
</span><span id="line-138"></span><span>                   </span><span class="hs-keyword">else</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">10000000000</span></span><span>
</span><span id="line-139"></span><span>                        </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; t
forall {a} {p}. (Ord a, Num p) =&gt; a -&gt; a -&gt; p
</span><a href="#local-6989586621679114746"><span class="hs-identifier hs-var">fin</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">1000000000</span></span><span>
</span><span id="line-140"></span><span>                        </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">10</span></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; t
forall {a} {p}. (Ord a, Num p) =&gt; a -&gt; a -&gt; p
</span><a href="#local-6989586621679114746"><span class="hs-identifier hs-var">fin</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">100000000000</span></span><span>
</span><span id="line-141"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">t -&gt; Word64 -&gt; t
</span><a href="#local-6989586621679114815"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114748"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">12</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679114747"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#quot"><span class="hs-operator hs-var">`quot`</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">1000000000000</span></span><span class="hs-special">)</span><span>
</span><span id="line-142"></span><span>        </span><span id="local-6989586621679114746"><span class="annot"><span class="annottext">fin :: a -&gt; a -&gt; p
</span><a href="#local-6989586621679114746"><span class="hs-identifier hs-var hs-var">fin</span></a></span></span><span> </span><span id="local-6989586621679114740"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114740"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span id="local-6989586621679114739"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114739"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114740"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114739"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">1</span></span><span> </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">p
</span><span class="hs-number">0</span></span><span>
</span><span id="line-143"></span><span>
</span><span id="line-144"></span><span id="local-6989586621679114738"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-identifier hs-type">hexadecimal</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679114738"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679114738"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-identifier hs-type">Builder</span></a></span></span><span>
</span><span id="line-145"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-pragma hs-type">Int</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-146"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int8"><span class="hs-pragma hs-type">Int8</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-147"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-pragma hs-type">Int16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-148"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-pragma hs-type">Int32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-149"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-pragma hs-type">Int64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-150"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Word"><span class="hs-pragma hs-type">Word</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-151"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-pragma hs-type">Word8</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-152"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-pragma hs-type">Word16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-153"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-pragma hs-type">Word32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-154"></span><span class="hs-pragma">{-# SPECIALIZE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-pragma hs-type">Word64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-155"></span><span class="hs-pragma">{-# RULES</span><span> </span><span class="annot"><span class="hs-pragma">&quot;hexadecimal/Integer&quot;</span></span><span>
</span><span id="line-156"></span><span>    </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexInteger"><span class="hs-pragma hs-type">hexInteger</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><span class="hs-pragma hs-type">Integer</span></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-pragma hs-type">Builder</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-157"></span><span id="hexadecimal"><span class="annot"><span class="annottext">hexadecimal :: forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-identifier hs-var hs-var">hexadecimal</span></a></span></span><span> </span><span id="local-6989586621679114727"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114727"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-158"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114727"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; Builder
forall a. HasCallStack =&gt; [Char] -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><a href="Data.Text.Lazy.Builder.Int.html#hexErrMsg"><span class="hs-identifier hs-var">hexErrMsg</span></a></span><span>
</span><span id="line-159"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Builder
forall a. Integral a =&gt; a -&gt; Builder
</span><a href="#local-6989586621679114724"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114727"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-160"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-161"></span><span>    </span><span id="local-6989586621679114724"><span class="annot"><span class="annottext">go :: a -&gt; Builder
</span><a href="#local-6989586621679114724"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621679114711"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114711"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114711"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">16</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Builder
forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#hexDigit"><span class="hs-identifier hs-var">hexDigit</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114711"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-162"></span><span>         </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Builder
</span><a href="#local-6989586621679114724"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114711"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#quot"><span class="hs-operator hs-var">`quot`</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Builder -&gt; Builder
</span><a href="Data.Text.Internal.Builder.Functions.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Builder
forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#hexDigit"><span class="hs-identifier hs-var">hexDigit</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114711"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#rem"><span class="hs-operator hs-var">`rem`</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span>
</span><span id="line-163"></span><span class="hs-pragma">{-# NOINLINE</span><span class="hs-pragma">[</span><span class="hs-pragma">0</span><span class="hs-pragma">]</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-pragma hs-type">hexadecimal</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-164"></span><span>
</span><span id="line-165"></span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexInteger"><span class="hs-identifier hs-type">hexInteger</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-identifier hs-type">Builder</span></a></span><span>
</span><span id="line-166"></span><span id="hexInteger"><span class="annot"><span class="annottext">hexInteger :: Integer -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#hexInteger"><span class="hs-identifier hs-var hs-var">hexInteger</span></a></span></span><span> </span><span id="local-6989586621679114708"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114708"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-167"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114708"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; Builder
forall a. HasCallStack =&gt; [Char] -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><a href="Data.Text.Lazy.Builder.Int.html#hexErrMsg"><span class="hs-identifier hs-var">hexErrMsg</span></a></span><span>
</span><span id="line-168"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Integer -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#integer"><span class="hs-identifier hs-var">integer</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114708"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-169"></span><span>
</span><span id="line-170"></span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexErrMsg"><span class="hs-identifier hs-type">hexErrMsg</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-171"></span><span id="hexErrMsg"><span class="annot"><span class="annottext">hexErrMsg :: [Char]
</span><a href="Data.Text.Lazy.Builder.Int.html#hexErrMsg"><span class="hs-identifier hs-var hs-var">hexErrMsg</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;Data.Text.Lazy.Builder.Int.hexadecimal: applied to negative number&quot;</span></span><span>
</span><span id="line-172"></span><span>
</span><span id="line-173"></span><span id="local-6989586621679114707"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexDigit"><span class="hs-identifier hs-type">hexDigit</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679114707"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679114707"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-identifier hs-type">Builder</span></a></span></span><span>
</span><span id="line-174"></span><span id="hexDigit"><span class="annot"><span class="annottext">hexDigit :: forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#hexDigit"><span class="hs-identifier hs-var hs-var">hexDigit</span></a></span></span><span> </span><span id="local-6989586621679114692"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114692"><span class="hs-identifier hs-var">n</span></a></span></span><span>
</span><span id="line-175"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114692"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C%3D"><span class="hs-operator hs-var">&lt;=</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">9</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Builder
</span><a href="Data.Text.Internal.Builder.html#singleton"><span class="hs-identifier hs-var">singleton</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Builder) -&gt; Char -&gt; Builder
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Char
</span><a href="Data.Text.Internal.Builder.Functions.html#i2d"><span class="hs-identifier hs-var">i2d</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114692"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-176"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Builder
</span><a href="Data.Text.Internal.Builder.html#singleton"><span class="hs-identifier hs-var">singleton</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Builder) -&gt; Char -&gt; Builder
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Char
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679114692"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">87</span></span><span class="hs-special">)</span><span>
</span><span id="line-177"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#hexDigit"><span class="hs-pragma hs-type">hexDigit</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-178"></span><span>
</span><span id="line-179"></span><span class="hs-keyword">data</span><span> </span><span id="T"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-var">T</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="T"><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-var">T</span></a></span></span><span> </span><span class="hs-glyph">!</span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span>
</span><span id="line-180"></span><span>
</span><span id="line-181"></span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#integer"><span class="hs-identifier hs-type">integer</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-identifier hs-type">Builder</span></a></span><span>
</span><span id="line-182"></span><span id="integer"><span class="annot"><span class="annottext">integer :: Int -&gt; Integer -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#integer"><span class="hs-identifier hs-var hs-var">integer</span></a></span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span> </span><span id="local-6989586621679114687"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114687"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-183"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span id="local-6989586621679114686"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114686"><span class="hs-identifier hs-var">i'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a. Num a =&gt; Integer -&gt; a
</span><a href="../../base/src/GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114687"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Integer
forall a. Integral a =&gt; a -&gt; Integer
</span><a href="../../base/src/GHC.Real.html#toInteger"><span class="hs-identifier hs-var">toInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114686"><span class="hs-identifier hs-var">i'</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114687"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-identifier hs-var">decimal</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114686"><span class="hs-identifier hs-var">i'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-184"></span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#integer"><span class="hs-identifier hs-var">integer</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span> </span><span id="local-6989586621679114685"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114685"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-185"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span id="local-6989586621679114684"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114684"><span class="hs-identifier hs-var">i'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a. Num a =&gt; Integer -&gt; a
</span><a href="../../base/src/GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114685"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Integer
forall a. Integral a =&gt; a -&gt; Integer
</span><a href="../../base/src/GHC.Real.html#toInteger"><span class="hs-identifier hs-var">toInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114684"><span class="hs-identifier hs-var">i'</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114685"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-identifier hs-var">hexadecimal</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114684"><span class="hs-identifier hs-var">i'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-186"></span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#integer"><span class="hs-identifier hs-var">integer</span></a></span><span> </span><span id="local-6989586621679114683"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114683"><span class="hs-identifier hs-var">base</span></a></span></span><span> </span><span id="local-6989586621679114682"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114682"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-187"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114682"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Builder
</span><a href="Data.Text.Internal.Builder.html#singleton"><span class="hs-identifier hs-var">singleton</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'-'</span></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Builder -&gt; Builder
</span><a href="Data.Text.Internal.Builder.Functions.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Builder
</span><a href="#local-6989586621679114681"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">-</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114682"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-188"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Builder
</span><a href="#local-6989586621679114681"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114682"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-189"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-190"></span><span>    </span><span id="local-6989586621679114681"><span class="annot"><span class="annottext">go :: Integer -&gt; Builder
</span><a href="#local-6989586621679114681"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621679114676"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114676"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114676"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3C"><span class="hs-operator hs-var">&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114675"><span class="hs-identifier hs-var">maxInt</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
</span><a href="#local-6989586621679114674"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a. Num a =&gt; Integer -&gt; a
</span><a href="../../base/src/GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114676"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-191"></span><span>         </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Integer] -&gt; Builder
</span><a href="#local-6989586621679114673"><span class="hs-identifier hs-var">putH</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; [Integer]
forall {t}. Integral t =&gt; t -&gt; t -&gt; [t]
</span><a href="#local-6989586621679114672"><span class="hs-identifier hs-var">splitf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114675"><span class="hs-identifier hs-var">maxInt</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114675"><span class="hs-identifier hs-var">maxInt</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114676"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-192"></span><span>
</span><span id="line-193"></span><span>    </span><span id="local-6989586621679114672"><span class="annot"><span class="annottext">splitf :: t -&gt; t -&gt; [t]
</span><a href="#local-6989586621679114672"><span class="hs-identifier hs-var hs-var">splitf</span></a></span></span><span> </span><span id="local-6989586621679114663"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114663"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679114662"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114662"><span class="hs-identifier hs-var">n</span></a></span></span><span>
</span><span id="line-194"></span><span>      </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114663"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114662"><span class="hs-identifier hs-var">n</span></a></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114662"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-195"></span><span>      </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">t -&gt; [t] -&gt; [t]
forall {t}. Integral t =&gt; t -&gt; [t] -&gt; [t]
</span><a href="#local-6989586621679114661"><span class="hs-identifier hs-var">splith</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114663"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">t -&gt; t -&gt; [t]
</span><a href="#local-6989586621679114672"><span class="hs-identifier hs-var">splitf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114663"><span class="hs-identifier hs-var">p</span></a></span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114663"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114662"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-196"></span><span>
</span><span id="line-197"></span><span>    </span><span id="local-6989586621679114661"><span class="annot"><span class="annottext">splith :: t -&gt; [t] -&gt; [t]
</span><a href="#local-6989586621679114661"><span class="hs-identifier hs-var hs-var">splith</span></a></span></span><span> </span><span id="local-6989586621679114649"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114649"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679114648"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114648"><span class="hs-identifier hs-var">n</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679114647"><span class="annot"><span class="annottext">[t]
</span><a href="#local-6989586621679114647"><span class="hs-identifier hs-var">ns</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114648"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; (t, t)
forall a. Integral a =&gt; a -&gt; a -&gt; (a, a)
</span><a href="../../base/src/GHC.Real.html#quotRem"><span class="hs-operator hs-var">`quotRem`</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114649"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-198"></span><span>                        </span><span class="hs-special">(</span><span id="local-6989586621679114646"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114646"><span class="hs-identifier hs-var">q</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679114645"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114645"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114646"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">0</span></span><span>     </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114646"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; [t] -&gt; [t]
forall a. a -&gt; [a] -&gt; [a]
</span><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-var">:</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114645"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; [t] -&gt; [t]
forall a. a -&gt; [a] -&gt; [a]
</span><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-var">:</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; [t] -&gt; [t]
forall {t}. Integral t =&gt; t -&gt; [t] -&gt; [t]
</span><a href="#local-6989586621679114644"><span class="hs-identifier hs-var">splitb</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114649"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">[t]
</span><a href="#local-6989586621679114647"><span class="hs-identifier hs-var">ns</span></a></span><span>
</span><span id="line-199"></span><span>                               </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114645"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; [t] -&gt; [t]
forall a. a -&gt; [a] -&gt; [a]
</span><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-var">:</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; [t] -&gt; [t]
forall {t}. Integral t =&gt; t -&gt; [t] -&gt; [t]
</span><a href="#local-6989586621679114644"><span class="hs-identifier hs-var">splitb</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114649"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">[t]
</span><a href="#local-6989586621679114647"><span class="hs-identifier hs-var">ns</span></a></span><span>
</span><span id="line-200"></span><span>    </span><span class="annot"><a href="#local-6989586621679114661"><span class="hs-identifier hs-var">splith</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[t]
</span><span class="hs-identifier">_</span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; [t]
forall a. HasCallStack =&gt; [Char] -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;splith: the impossible happened.&quot;</span></span><span>
</span><span id="line-201"></span><span>
</span><span id="line-202"></span><span>    </span><span id="local-6989586621679114644"><span class="annot"><span class="annottext">splitb :: t -&gt; [t] -&gt; [t]
</span><a href="#local-6989586621679114644"><span class="hs-identifier hs-var hs-var">splitb</span></a></span></span><span> </span><span id="local-6989586621679114641"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114641"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679114640"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114640"><span class="hs-identifier hs-var">n</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679114639"><span class="annot"><span class="annottext">[t]
</span><a href="#local-6989586621679114639"><span class="hs-identifier hs-var">ns</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114640"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; (t, t)
forall a. Integral a =&gt; a -&gt; a -&gt; (a, a)
</span><a href="../../base/src/GHC.Real.html#quotRem"><span class="hs-operator hs-var">`quotRem`</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114641"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-203"></span><span>                        </span><span class="hs-special">(</span><span id="local-6989586621679114638"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114638"><span class="hs-identifier hs-var">q</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679114637"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114637"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114638"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; [t] -&gt; [t]
forall a. a -&gt; [a] -&gt; [a]
</span><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-var">:</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114637"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; [t] -&gt; [t]
forall a. a -&gt; [a] -&gt; [a]
</span><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-var">:</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; [t] -&gt; [t]
</span><a href="#local-6989586621679114644"><span class="hs-identifier hs-var">splitb</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114641"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">[t]
</span><a href="#local-6989586621679114639"><span class="hs-identifier hs-var">ns</span></a></span><span>
</span><span id="line-204"></span><span>    </span><span class="annot"><a href="#local-6989586621679114644"><span class="hs-identifier hs-var">splitb</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[t]
</span><span class="hs-identifier">_</span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-205"></span><span>
</span><span id="line-206"></span><span>    </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-type">T</span></a></span><span> </span><span id="local-6989586621679114629"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114629"><span class="hs-identifier hs-var">maxInt10</span></a></span></span><span> </span><span id="local-6989586621679114628"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114628"><span class="hs-identifier hs-var">maxDigits10</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-207"></span><span>        </span><span class="annot"><span class="annottext">(T -&gt; Bool) -&gt; (T -&gt; T) -&gt; T -&gt; T
forall a. (a -&gt; Bool) -&gt; (a -&gt; a) -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#until"><span class="hs-identifier hs-var">until</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114626"><span class="hs-identifier hs-var">mi</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Bool) -&gt; (T -&gt; Integer) -&gt; T -&gt; Bool
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">10</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Integer) -&gt; (T -&gt; Integer) -&gt; T -&gt; Integer
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">T -&gt; Integer
</span><a href="#local-6989586621679114625"><span class="hs-identifier hs-var">fstT</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-type">T</span></a></span><span> </span><span id="local-6989586621679114624"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114624"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679114623"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114623"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int -&gt; T
</span><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-var">T</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114624"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">10</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114623"><span class="hs-identifier hs-var">d</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Int -&gt; T
</span><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-var">T</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">10</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span>
</span><span id="line-208"></span><span>      </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679114626"><span class="annot"><span class="annottext">mi :: Integer
</span><a href="#local-6989586621679114626"><span class="hs-identifier hs-var hs-var">mi</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Integer
forall a. Integral a =&gt; a -&gt; Integer
</span><a href="../../base/src/GHC.Real.html#toInteger"><span class="hs-identifier hs-var">toInteger</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
forall a. Bounded a =&gt; a
</span><a href="../../base/src/GHC.Enum.html#maxBound"><span class="hs-identifier hs-var">maxBound</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-209"></span><span>    </span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-type">T</span></a></span><span> </span><span id="local-6989586621679114612"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114612"><span class="hs-identifier hs-var">maxInt16</span></a></span></span><span> </span><span id="local-6989586621679114611"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114611"><span class="hs-identifier hs-var">maxDigits16</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-210"></span><span>        </span><span class="annot"><span class="annottext">(T -&gt; Bool) -&gt; (T -&gt; T) -&gt; T -&gt; T
forall a. (a -&gt; Bool) -&gt; (a -&gt; a) -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#until"><span class="hs-identifier hs-var">until</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114610"><span class="hs-identifier hs-var">mi</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Bool) -&gt; (T -&gt; Integer) -&gt; T -&gt; Bool
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Integer) -&gt; (T -&gt; Integer) -&gt; T -&gt; Integer
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">T -&gt; Integer
</span><a href="#local-6989586621679114625"><span class="hs-identifier hs-var">fstT</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-type">T</span></a></span><span> </span><span id="local-6989586621679114609"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114609"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679114608"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114608"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int -&gt; T
</span><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-var">T</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114609"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114608"><span class="hs-identifier hs-var">d</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Int -&gt; T
</span><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-var">T</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">16</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span>
</span><span id="line-211"></span><span>      </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679114610"><span class="annot"><span class="annottext">mi :: Integer
</span><a href="#local-6989586621679114610"><span class="hs-identifier hs-var hs-var">mi</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Integer
forall a. Integral a =&gt; a -&gt; Integer
</span><a href="../../base/src/GHC.Real.html#toInteger"><span class="hs-identifier hs-var">toInteger</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
forall a. Bounded a =&gt; a
</span><a href="../../base/src/GHC.Enum.html#maxBound"><span class="hs-identifier hs-var">maxBound</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-212"></span><span>
</span><span id="line-213"></span><span>    </span><span id="local-6989586621679114625"><span class="annot"><span class="annottext">fstT :: T -&gt; Integer
</span><a href="#local-6989586621679114625"><span class="hs-identifier hs-var hs-var">fstT</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#T"><span class="hs-identifier hs-type">T</span></a></span><span> </span><span id="local-6989586621679114605"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114605"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114605"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-214"></span><span>
</span><span id="line-215"></span><span>    </span><span id="local-6989586621679114675"><span class="annot"><span class="annottext">maxInt :: Integer
</span><a href="#local-6989586621679114675"><span class="hs-identifier hs-var hs-var">maxInt</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114683"><span class="hs-identifier hs-var">base</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114629"><span class="hs-identifier hs-var">maxInt10</span></a></span><span>
</span><span id="line-216"></span><span>           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114612"><span class="hs-identifier hs-var">maxInt16</span></a></span><span>
</span><span id="line-217"></span><span>    </span><span id="local-6989586621679114600"><span class="annot"><span class="annottext">maxDigits :: Int
</span><a href="#local-6989586621679114600"><span class="hs-identifier hs-var hs-var">maxDigits</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114683"><span class="hs-identifier hs-var">base</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114628"><span class="hs-identifier hs-var">maxDigits10</span></a></span><span>
</span><span id="line-218"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114611"><span class="hs-identifier hs-var">maxDigits16</span></a></span><span>
</span><span id="line-219"></span><span>
</span><span id="line-220"></span><span>    </span><span id="local-6989586621679114673"><span class="annot"><span class="annottext">putH :: [Integer] -&gt; Builder
</span><a href="#local-6989586621679114673"><span class="hs-identifier hs-var hs-var">putH</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679114593"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114593"><span class="hs-identifier hs-var">n</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679114592"><span class="annot"><span class="annottext">[Integer]
</span><a href="#local-6989586621679114592"><span class="hs-identifier hs-var">ns</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114593"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; (Integer, Integer)
forall a. Integral a =&gt; a -&gt; a -&gt; (a, a)
</span><a href="../../base/src/GHC.Real.html#quotRem"><span class="hs-operator hs-var">`quotRem`</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114675"><span class="hs-identifier hs-var">maxInt</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-221"></span><span>                    </span><span class="hs-special">(</span><span id="local-6989586621679114591"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114591"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679114590"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114590"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span>
</span><span id="line-222"></span><span>                        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114589"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>     </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
</span><a href="#local-6989586621679114674"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114589"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Builder -&gt; Builder
</span><a href="Data.Text.Internal.Builder.Functions.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
</span><a href="#local-6989586621679114588"><span class="hs-identifier hs-var">pblock</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114587"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Builder -&gt; Builder
</span><a href="Data.Text.Internal.Builder.Functions.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Integer] -&gt; Builder
</span><a href="#local-6989586621679114586"><span class="hs-identifier hs-var">putB</span></a></span><span> </span><span class="annot"><span class="annottext">[Integer]
</span><a href="#local-6989586621679114592"><span class="hs-identifier hs-var">ns</span></a></span><span>
</span><span id="line-223"></span><span>                        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
</span><a href="#local-6989586621679114674"><span class="hs-identifier hs-var">int</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114587"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Builder -&gt; Builder
</span><a href="Data.Text.Internal.Builder.Functions.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Integer] -&gt; Builder
</span><a href="#local-6989586621679114586"><span class="hs-identifier hs-var">putB</span></a></span><span> </span><span class="annot"><span class="annottext">[Integer]
</span><a href="#local-6989586621679114592"><span class="hs-identifier hs-var">ns</span></a></span><span>
</span><span id="line-224"></span><span>                        </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679114589"><span class="annot"><span class="annottext">q :: Int
</span><a href="#local-6989586621679114589"><span class="hs-identifier hs-var hs-var">q</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a. Num a =&gt; Integer -&gt; a
</span><a href="../../base/src/GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114591"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-225"></span><span>                              </span><span id="local-6989586621679114587"><span class="annot"><span class="annottext">r :: Int
</span><a href="#local-6989586621679114587"><span class="hs-identifier hs-var hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a. Num a =&gt; Integer -&gt; a
</span><a href="../../base/src/GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114590"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-226"></span><span>    </span><span class="annot"><a href="#local-6989586621679114673"><span class="hs-identifier hs-var">putH</span></a></span><span> </span><span class="annot"><span class="annottext">[Integer]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Char] -&gt; Builder
forall a. HasCallStack =&gt; [Char] -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">[Char]
</span><span class="hs-string">&quot;putH: the impossible happened&quot;</span></span><span>
</span><span id="line-227"></span><span>
</span><span id="line-228"></span><span>    </span><span id="local-6989586621679114586"><span class="annot"><span class="annottext">putB :: [Integer] -&gt; Builder
</span><a href="#local-6989586621679114586"><span class="hs-identifier hs-var hs-var">putB</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679114580"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114580"><span class="hs-identifier hs-var">n</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679114579"><span class="annot"><span class="annottext">[Integer]
</span><a href="#local-6989586621679114579"><span class="hs-identifier hs-var">ns</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114580"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; (Integer, Integer)
forall a. Integral a =&gt; a -&gt; a -&gt; (a, a)
</span><a href="../../base/src/GHC.Real.html#quotRem"><span class="hs-operator hs-var">`quotRem`</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114675"><span class="hs-identifier hs-var">maxInt</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-229"></span><span>                    </span><span class="hs-special">(</span><span id="local-6989586621679114578"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114578"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679114577"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114577"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
</span><a href="#local-6989586621679114588"><span class="hs-identifier hs-var">pblock</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114576"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Builder -&gt; Builder
</span><a href="Data.Text.Internal.Builder.Functions.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
</span><a href="#local-6989586621679114588"><span class="hs-identifier hs-var">pblock</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114575"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Builder -&gt; Builder
</span><a href="Data.Text.Internal.Builder.Functions.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Integer] -&gt; Builder
</span><a href="#local-6989586621679114586"><span class="hs-identifier hs-var">putB</span></a></span><span> </span><span class="annot"><span class="annottext">[Integer]
</span><a href="#local-6989586621679114579"><span class="hs-identifier hs-var">ns</span></a></span><span>
</span><span id="line-230"></span><span>                        </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679114576"><span class="annot"><span class="annottext">q :: Int
</span><a href="#local-6989586621679114576"><span class="hs-identifier hs-var hs-var">q</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a. Num a =&gt; Integer -&gt; a
</span><a href="../../base/src/GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114578"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-231"></span><span>                              </span><span id="local-6989586621679114575"><span class="annot"><span class="annottext">r :: Int
</span><a href="#local-6989586621679114575"><span class="hs-identifier hs-var hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a. Num a =&gt; Integer -&gt; a
</span><a href="../../base/src/GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679114577"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-232"></span><span>    </span><span class="annot"><a href="#local-6989586621679114586"><span class="hs-identifier hs-var">putB</span></a></span><span> </span><span class="annot"><span class="annottext">[Integer]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Builder
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">Data.Monoid.mempty</span></a></span><span>
</span><span id="line-233"></span><span>
</span><span id="line-234"></span><span>    </span><span class="annot"><a href="#local-6989586621679114674"><span class="hs-identifier hs-type">int</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Text.Internal.Builder.html#Builder"><span class="hs-identifier hs-type">Builder</span></a></span><span>
</span><span id="line-235"></span><span>    </span><span id="local-6989586621679114674"><span class="annot"><span class="annottext">int :: Int -&gt; Builder
</span><a href="#local-6989586621679114674"><span class="hs-identifier hs-var hs-var">int</span></a></span></span><span> </span><span id="local-6989586621679114572"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114572"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114683"><span class="hs-identifier hs-var">base</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#decimal"><span class="hs-identifier hs-var">decimal</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114572"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-236"></span><span>          </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#hexadecimal"><span class="hs-identifier hs-var">hexadecimal</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114572"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-237"></span><span>
</span><span id="line-238"></span><span>    </span><span id="local-6989586621679114588"><span class="annot"><span class="annottext">pblock :: Int -&gt; Builder
</span><a href="#local-6989586621679114588"><span class="hs-identifier hs-var hs-var">pblock</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Builder
forall {t}. (Eq t, Num t) =&gt; t -&gt; Int -&gt; Builder
</span><a href="#local-6989586621679114569"><span class="hs-identifier hs-var">loop</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114600"><span class="hs-identifier hs-var">maxDigits</span></a></span><span>
</span><span id="line-239"></span><span>      </span><span class="hs-keyword">where</span><span>
</span><span id="line-240"></span><span>        </span><span id="local-6989586621679114569"><span class="annot"><span class="annottext">loop :: t -&gt; Int -&gt; Builder
</span><a href="#local-6989586621679114569"><span class="hs-identifier hs-var hs-var">loop</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679114560"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114560"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679114559"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114559"><span class="hs-identifier hs-var">n</span></a></span></span><span>
</span><span id="line-241"></span><span>            </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114560"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">1</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#hexDigit"><span class="hs-identifier hs-var">hexDigit</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114559"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-242"></span><span>            </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">t -&gt; Int -&gt; Builder
</span><a href="#local-6989586621679114569"><span class="hs-identifier hs-var">loop</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679114560"><span class="hs-identifier hs-var">d</span></a></span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">t
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114558"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Builder -&gt; Builder
</span><a href="Data.Text.Internal.Builder.Functions.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Builder
forall a. Integral a =&gt; a -&gt; Builder
</span><a href="Data.Text.Lazy.Builder.Int.html#hexDigit"><span class="hs-identifier hs-var">hexDigit</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114557"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-243"></span><span>            </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679114558"><span class="annot"><span class="annottext">q :: Int
</span><a href="#local-6989586621679114558"><span class="hs-identifier hs-var hs-var">q</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114559"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
</span><a href="../../base/src/GHC.Base.html#quotInt"><span class="hs-operator hs-var">`quotInt`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114683"><span class="hs-identifier hs-var">base</span></a></span><span>
</span><span id="line-244"></span><span>                  </span><span id="local-6989586621679114557"><span class="annot"><span class="annottext">r :: Int
</span><a href="#local-6989586621679114557"><span class="hs-identifier hs-var hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114559"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
</span><a href="../../base/src/GHC.Base.html#remInt"><span class="hs-operator hs-var">`remInt`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679114683"><span class="hs-identifier hs-var">base</span></a></span><span>
</span><span id="line-245"></span><span>
</span><span id="line-246"></span><span class="annot"><a href="Data.Text.Lazy.Builder.Int.html#word8ToWord16"><span class="hs-identifier hs-type">word8ToWord16</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-247"></span><span id="word8ToWord16"><span class="annot"><span class="annottext">word8ToWord16 :: Word8 -&gt; Word16
</span><a href="Data.Text.Lazy.Builder.Int.html#word8ToWord16"><span class="hs-identifier hs-var hs-var">word8ToWord16</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span>
</span><span id="line-248"></span></pre></body></html>